home *** CD-ROM | disk | FTP | other *** search
- Path: xanth!mcnc!rutgers!mit-eddie!ll-xn!adelie!infinet!ulowell!page
- From: page@swan.ulowell.edu (Bob Page)
- Newsgroups: comp.sources.amiga
- Subject: v02i001: Windowed search (context grep)
- Message-ID: <9708@swan.ulowell.edu>
- Date: 19 Oct 88 00:05:16 GMT
- Organization: University of Lowell, Computer Science Dept.
- Lines: 2143
- Approved: page@swan.ulowell.edu
-
- Submitted-by: mrr@amanpt1.zone1.com (Mark Rinfret)
- Posting-number: Volume 2, Issue 1
- Archive-name: util/wns
-
- Here's a little search utility which appeared in one of the major
- sources groups recently (unix? misc?). I made some minor changes to
- the program proper and added in some regular expression stuff that I
- had with a copy of NGrep. I can't take credit for anything original
- here, but it was an easy port so I thought I'd pass it along.
-
- Mark Rinfret, 10/18/88
- ----------------------Apply Scissors Here-------------------------------
- #! /bin/sh
- # This is a shell archive. Remove anything before this line, then unpack
- # it by saving it into a file and typing "sh file". To overwrite existing
- # files, type "sh file -c". You can also feed this as standard input via
- # unshar, or by typing "sh <file", e.g.. If this archive is complete, you
- # will see the following message at the end:
- # "End of archive 1 (of 1)."
- # Contents: Makefile regexp.h regmagic.h regerror.c regexp.c wns.c
- # wns.man wns.1
- # Wrapped by mrr@mrramiga on Sun Oct 9 21:50:20 1988
- # This shar was created for Amiga and may have pathnames which
- # are incompatible with Unix. Replace colon (:) with slash (/)
- # in offending pathnames.
- if test -f Makefile -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"Makefile\"
- else
- echo shar: Extracting \"Makefile\" \(675 characters\)
- sed "s/^X//" >Makefile <<'END_OF_Makefile'
- X# Makefile for wns
- X#
- XCC = cc
- X
- X# Define in CFLAGS:
- X# SYSINC if include file hierarchy includes the sys/ directory
- X# REGEX if using berkeley-style re_exec() and re_comp()
- X# REGCMP if using regcmp() and regex()
- X# REGCOMP if using regcomp() and regexec()
- X# OS_UNIX if running under unix (or AmigaDOS)
- X# AMIGA if running under AmigaDOS
- X# OS_CPM if running under CP/M80
- X# STRCSPN if you need the strcspn() function.
- X#
- X#
- X#CFLAGS=-DOS_UNIX -DREGCMP -DSYSINC
- XCFLAGS=-DOS_UNIX -DAMIGA -DREGCOMP -DSTRCSPN -n
- X#
- X# Define LIBS to reflect the librar[y][ies] needed to fetch the r/e routines.
- X#
- XLIBS=-lc
- X
- X#
- XWNSOBJS=wns.o regexp.o regerror.o
- X
- Xwns: $(WNSOBJS)
- X ln $(WNSOBJS) $(LIBS) -o wns
- END_OF_Makefile
- if test 675 -ne `wc -c <Makefile`; then
- echo shar: \"Makefile\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f regexp.h -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"regexp.h\"
- else
- echo shar: Extracting \"regexp.h\" \(574 characters\)
- sed "s/^X//" >regexp.h <<'END_OF_regexp.h'
- X/*
- X * Definitions etc. for regexp(3) routines.
- X *
- X * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof],
- X * not the System V one.
- X */
- X#define NSUBEXP 10
- Xtypedef struct regexp {
- X char *startp[NSUBEXP];
- X char *endp[NSUBEXP];
- X char regstart; /* Internal use only. */
- X char reganch; /* Internal use only. */
- X char *regmust; /* Internal use only. */
- X int regmlen; /* Internal use only. */
- X char program[1]; /* Unwarranted chumminess with compiler. */
- X} regexp;
- X
- Xextern regexp *regcomp();
- Xextern int regexec();
- Xextern void regsub();
- Xextern void regerror();
- END_OF_regexp.h
- if test 574 -ne `wc -c <regexp.h`; then
- echo shar: \"regexp.h\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f regmagic.h -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"regmagic.h\"
- else
- echo shar: Extracting \"regmagic.h\" \(153 characters\)
- sed "s/^X//" >regmagic.h <<'END_OF_regmagic.h'
- X/*
- X * The first byte of the regexp internal "program" is actually this magic
- X * number; the start node begins in the second byte.
- X */
- X#define MAGIC 0234
- END_OF_regmagic.h
- if test 153 -ne `wc -c <regmagic.h`; then
- echo shar: \"regmagic.h\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f regerror.c -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"regerror.c\"
- else
- echo shar: Extracting \"regerror.c\" \(170 characters\)
- sed "s/^X//" >regerror.c <<'END_OF_regerror.c'
- X#include <stdio.h>
- X
- Xvoid
- Xregerror(s)
- Xchar *s;
- X{
- X#ifdef ERRAVAIL
- X error("regexp: %s", s);
- X#else
- X fprintf(stderr, "regexp(3): %s", s);
- X exit(1);
- X#endif
- X /* NOTREACHED */
- X}
- END_OF_regerror.c
- if test 170 -ne `wc -c <regerror.c`; then
- echo shar: \"regerror.c\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f regexp.c -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"regexp.c\"
- else
- echo shar: Extracting \"regexp.c\" \(27732 characters\)
- sed "s/^X//" >regexp.c <<'END_OF_regexp.c'
- X/*
- X * regcomp and regexec -- regsub and regerror are elsewhere
- X *
- X * Copyright (c) 1986 by University of Toronto.
- X * Written by Henry Spencer. Not derived from licensed software.
- X *
- X * Permission is granted to anyone to use this software for any
- X * purpose on any computer system, and to redistribute it freely,
- X * subject to the following restrictions:
- X *
- X * 1. The author is not responsible for the consequences of use of
- X * this software, no matter how awful, even if they arise
- X * from defects in it.
- X *
- X * 2. The origin of this software must not be misrepresented, either
- X * by explicit claim or by omission.
- X *
- X * 3. Altered versions must be plainly marked as such, and must not
- X * be misrepresented as being the original software.
- X *
- X * Beware that some of this code is subtly aware of the way operator
- X * precedence is structured in regular expressions. Serious changes in
- X * regular-expression syntax might require a total rethink.
- X
- X * 10/09/88 - This code was altered by Mark R. Rinfret for compatibility
- X * with the Amiga. (mrr@amanpt1.ZONE1.COM)
- X */
- X#include <stdio.h>
- X#include "regexp.h"
- X#include "regmagic.h"
- X
- X
- X/*
- X * The "internal use only" fields in regexp.h are present to pass info from
- X * compile to execute that permits the execute phase to run lots faster on
- X * simple cases. They are:
- X *
- X * regstart char that must begin a match; '\0' if none obvious
- X * reganch is the match anchored (at beginning-of-line only)?
- X * regmust string (pointer into program) that match must include, or NULL
- X * regmlen length of regmust string
- X *
- X * Regstart and reganch permit very fast decisions on suitable starting points
- X * for a match, cutting down the work a lot. Regmust permits fast rejection
- X * of lines that cannot possibly match. The regmust tests are costly enough
- X * that regcomp() supplies a regmust only if the r.e. contains something
- X * potentially expensive (at present, the only such thing detected is * or +
- X * at the start of the r.e., which can involve a lot of backup). Regmlen is
- X * supplied because the test in regexec() needs it and regcomp() is computing
- X * it anyway.
- X */
- X
- X/*
- X * Structure for regexp "program". This is essentially a linear encoding
- X * of a nondeterministic finite-state machine (aka syntax charts or
- X * "railroad normal form" in parsing technology). Each node is an opcode
- X * plus a "next" pointer, possibly plus an operand. "Next" pointers of
- X * all nodes except BRANCH implement concatenation; a "next" pointer with
- X * a BRANCH on both ends of it is connecting two alternatives. (Here we
- X * have one of the subtle syntax dependencies: an individual BRANCH (as
- X * opposed to a collection of them) is never concatenated with anything
- X * because of operator precedence.) The operand of some types of node is
- X * a literal string; for others, it is a node leading into a sub-FSM. In
- X * particular, the operand of a BRANCH node is the first node of the branch.
- X * (NB this is *not* a tree structure: the tail of the branch connects
- X * to the thing following the set of BRANCHes.) The opcodes are:
- X */
- X
- X/* definition number opnd? meaning */
- X#define END 0 /* no End of program. */
- X#define BOL 1 /* no Match "" at beginning of line. */
- X#define EOL 2 /* no Match "" at end of line. */
- X#define ANY 3 /* no Match any one character. */
- X#define ANYOF 4 /* str Match any character in this string. */
- X#define ANYBUT 5 /* str Match any character not in this string. */
- X#define BRANCH 6 /* node Match this alternative, or the next... */
- X#define BACK 7 /* no Match "", "next" ptr points backward. */
- X#define EXACTLY 8 /* str Match this string. */
- X#define NOTHING 9 /* no Match empty string. */
- X#define STAR 10 /* node Match this (simple) thing 0 or more times. */
- X#define PLUS 11 /* node Match this (simple) thing 1 or more times. */
- X#define OPEN 20 /* no Mark this point in input as start of #n. */
- X /* OPEN+1 is number 1, etc. */
- X#define CLOSE 30 /* no Analogous to OPEN. */
- X
- X/*
- X * Opcode notes:
- X *
- X * BRANCH The set of branches constituting a single choice are hooked
- X * together with their "next" pointers, since precedence prevents
- X * anything being concatenated to any individual branch. The
- X * "next" pointer of the last BRANCH in a choice points to the
- X * thing following the whole choice. This is also where the
- X * final "next" pointer of each individual branch points; each
- X * branch starts with the operand node of a BRANCH node.
- X *
- X * BACK Normal "next" pointers all implicitly point forward; BACK
- X * exists to make loop structures possible.
- X *
- X * STAR,PLUS '?', and complex '*' and '+', are implemented as circular
- X * BRANCH structures using BACK. Simple cases (one character
- X * per match) are implemented with STAR and PLUS for speed
- X * and to minimize recursive plunges.
- X *
- X * OPEN,CLOSE ...are numbered at compile time.
- X */
- X
- X/*
- X * A node is one char of opcode followed by two chars of "next" pointer.
- X * "Next" pointers are stored as two 8-bit pieces, high order first. The
- X * value is a positive offset from the opcode of the node containing it.
- X * An operand, if any, simply follows the node. (Note that much of the
- X * code generation knows about this implicit relationship.)
- X *
- X * Using two bytes for the "next" pointer is vast overkill for most things,
- X * but allows patterns to get big without disasters.
- X */
- X#define OP(p) (*(p))
- X#define NEXT(p) (((*((p)+1)&0377)<<8) + *((p)+2)&0377)
- X#define OPERAND(p) ((p) + 3)
- X
- X/*
- X * See regmagic.h for one further detail of program structure.
- X */
- X
- X
- X/*
- X * Utility definitions.
- X */
- X#ifndef CHARBITS
- X#define UCHARAT(p) ((int)*(unsigned char *)(p))
- X#else
- X#define UCHARAT(p) ((int)*(p)&CHARBITS)
- X#endif
- X
- X#define FAIL(m) { regerror(m); return(NULL); }
- X#define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?')
- X#define META "^$.[()|?+*\\"
- X
- X/*
- X * Flags to be passed up and down.
- X */
- X#define HASWIDTH 01 /* Known never to match null string. */
- X#define SIMPLE 02 /* Simple enough to be STAR/PLUS operand. */
- X#define SPSTART 04 /* Starts with * or +. */
- X#define WORST 0 /* Worst case. */
- X
- X/*
- X * Global work variables for regcomp().
- X */
- Xstatic char *regparse; /* Input-scan pointer. */
- Xstatic int regnpar; /* () count. */
- Xstatic char regdummy;
- Xstatic char *regcode; /* Code-emit pointer; ®dummy = don't. */
- Xstatic long regsize; /* Code size. */
- X
- X/*
- X * Forward declarations for regcomp()'s friends.
- X */
- X#ifndef STATIC
- X#define STATIC static
- X#endif
- XSTATIC char *reg();
- XSTATIC char *regbranch();
- XSTATIC char *regpiece();
- XSTATIC char *regatom();
- XSTATIC char *regnode();
- XSTATIC char *regnext();
- XSTATIC void regc();
- XSTATIC void reginsert();
- XSTATIC void regtail();
- XSTATIC void regoptail();
- X#ifdef STRCSPN
- XSTATIC int strcspn();
- X#endif
- X
- X/*
- X - regcomp - compile a regular expression into internal code
- X *
- X * We can't allocate space until we know how big the compiled form will be,
- X * but we can't compile it (and thus know how big it is) until we've got a
- X * place to put the code. So we cheat: we compile it twice, once with code
- X * generation turned off and size counting turned on, and once "for real".
- X * This also means that we don't allocate space until we are sure that the
- X * thing really will compile successfully, and we never have to move the
- X * code and thus invalidate pointers into it. (Note that it has to be in
- X * one piece because free() must be able to free it all.)
- X *
- X * Beware that the optimization-preparation code in here knows about some
- X * of the structure of the compiled regexp.
- X */
- Xregexp *
- Xregcomp(exp)
- Xchar *exp;
- X{
- X register regexp *r;
- X register char *scan;
- X register char *longest;
- X register int len;
- X int flags;
- X extern char *malloc();
- X
- X if (exp == NULL)
- X FAIL("NULL argument");
- X
- X /* First pass: determine size, legality. */
- X regparse = exp;
- X regnpar = 1;
- X regsize = 0L;
- X regcode = ®dummy;
- X regc(MAGIC);
- X if (reg(0, &flags) == NULL)
- X return(NULL);
- X
- X /* Small enough for pointer-storage convention? */
- X if (regsize >= 32767L) /* Probably could be 65535L. */
- X FAIL("regexp too big");
- X
- X /* Allocate space. */
- X r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize);
- X if (r == NULL)
- X FAIL("out of space");
- X
- X /* Second pass: emit code. */
- X regparse = exp;
- X regnpar = 1;
- X regcode = r->program;
- X regc(MAGIC);
- X if (reg(0, &flags) == NULL)
- X return(NULL);
- X
- X /* Dig out information for optimizations. */
- X r->regstart = '\0'; /* Worst-case defaults. */
- X r->reganch = 0;
- X r->regmust = NULL;
- X r->regmlen = 0;
- X scan = r->program+1; /* First BRANCH. */
- X if (OP(regnext(scan)) == END) { /* Only one top-level choice. */
- X scan = OPERAND(scan);
- X
- X /* Starting-point info. */
- X if (OP(scan) == EXACTLY)
- X r->regstart = *OPERAND(scan);
- X else if (OP(scan) == BOL)
- X r->reganch++;
- X
- X /*
- X * If there's something expensive in the r.e., find the
- X * longest literal string that must appear and make it the
- X * regmust. Resolve ties in favor of later strings, since
- X * the regstart check works with the beginning of the r.e.
- X * and avoiding duplication strengthens checking. Not a
- X * strong reason, but sufficient in the absence of others.
- X */
- X if (flags&SPSTART) {
- X longest = NULL;
- X len = 0;
- X for (; scan != NULL; scan = regnext(scan))
- X if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
- X longest = OPERAND(scan);
- X len = strlen(OPERAND(scan));
- X }
- X r->regmust = longest;
- X r->regmlen = len;
- X }
- X }
- X
- X return(r);
- X}
- X
- X/*
- X - reg - regular expression, i.e. main body or parenthesized thing
- X *
- X * Caller must absorb opening parenthesis.
- X *
- X * Combining parenthesis handling with the base level of regular expression
- X * is a trifle forced, but the need to tie the tails of the branches to what
- X * follows makes it hard to avoid.
- X */
- Xstatic char *
- Xreg(paren, flagp)
- Xint paren; /* Parenthesized? */
- Xint *flagp;
- X{
- X register char *ret;
- X register char *br;
- X register char *ender;
- X register int parno;
- X int flags;
- X
- X *flagp = HASWIDTH; /* Tentatively. */
- X
- X /* Make an OPEN node, if parenthesized. */
- X if (paren) {
- X if (regnpar >= NSUBEXP)
- X FAIL("too many ()");
- X parno = regnpar;
- X regnpar++;
- X ret = regnode(OPEN+parno);
- X } else
- X ret = NULL;
- X
- X /* Pick up the branches, linking them together. */
- X br = regbranch(&flags);
- X if (br == NULL)
- X return(NULL);
- X if (ret != NULL)
- X regtail(ret, br); /* OPEN -> first. */
- X else
- X ret = br;
- X if (!(flags&HASWIDTH))
- X *flagp &= ~HASWIDTH;
- X *flagp |= flags&SPSTART;
- X while (*regparse == '|') {
- X regparse++;
- X br = regbranch(&flags);
- X if (br == NULL)
- X return(NULL);
- X regtail(ret, br); /* BRANCH -> BRANCH. */
- X if (!(flags&HASWIDTH))
- X *flagp &= ~HASWIDTH;
- X *flagp |= flags&SPSTART;
- X }
- X
- X /* Make a closing node, and hook it on the end. */
- X ender = regnode((paren) ? CLOSE+parno : END);
- X regtail(ret, ender);
- X
- X /* Hook the tails of the branches to the closing node. */
- X for (br = ret; br != NULL; br = regnext(br))
- X regoptail(br, ender);
- X
- X /* Check for proper termination. */
- X if (paren && *regparse++ != ')') {
- X FAIL("unmatched ()");
- X } else if (!paren && *regparse != '\0') {
- X if (*regparse == ')') {
- X FAIL("unmatched ()");
- X } else
- X FAIL("junk on end"); /* "Can't happen". */
- X /* NOTREACHED */
- X }
- X
- X return(ret);
- X}
- X
- X/*
- X - regbranch - one alternative of an | operator
- X *
- X * Implements the concatenation operator.
- X */
- Xstatic char *
- Xregbranch(flagp)
- Xint *flagp;
- X{
- X register char *ret;
- X register char *chain;
- X register char *latest;
- X int flags;
- X
- X *flagp = WORST; /* Tentatively. */
- X
- X ret = regnode(BRANCH);
- X chain = NULL;
- X while (*regparse != '\0' && *regparse != '|' && *regparse != ')') {
- X latest = regpiece(&flags);
- X if (latest == NULL)
- X return(NULL);
- X *flagp |= flags&HASWIDTH;
- X if (chain == NULL) /* First piece. */
- X *flagp |= flags&SPSTART;
- X else
- X regtail(chain, latest);
- X chain = latest;
- X }
- X if (chain == NULL) /* Loop ran zero times. */
- X (void) regnode(NOTHING);
- X
- X return(ret);
- X}
- X
- X/*
- X - regpiece - something followed by possible [*+?]
- X *
- X * Note that the branching code sequences used for ? and the general cases
- X * of * and + are somewhat optimized: they use the same NOTHING node as
- X * both the endmarker for their branch list and the body of the last branch.
- X * It might seem that this node could be dispensed with entirely, but the
- X * endmarker role is not redundant.
- X */
- Xstatic char *
- Xregpiece(flagp)
- Xint *flagp;
- X{
- X register char *ret;
- X register char op;
- X register char *next;
- X int flags;
- X
- X ret = regatom(&flags);
- X if (ret == NULL)
- X return(NULL);
- X
- X op = *regparse;
- X if (!ISMULT(op)) {
- X *flagp = flags;
- X return(ret);
- X }
- X
- X if (!(flags&HASWIDTH) && op != '?')
- X FAIL("*+ operand could be empty");
- X *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
- X
- X if (op == '*' && (flags&SIMPLE))
- X reginsert(STAR, ret);
- X else if (op == '*') {
- X /* Emit x* as (x&|), where & means "self". */
- X reginsert(BRANCH, ret); /* Either x */
- X regoptail(ret, regnode(BACK)); /* and loop */
- X regoptail(ret, ret); /* back */
- X regtail(ret, regnode(BRANCH)); /* or */
- X regtail(ret, regnode(NOTHING)); /* null. */
- X } else if (op == '+' && (flags&SIMPLE))
- X reginsert(PLUS, ret);
- X else if (op == '+') {
- X /* Emit x+ as x(&|), where & means "self". */
- X next = regnode(BRANCH); /* Either */
- X regtail(ret, next);
- X regtail(regnode(BACK), ret); /* loop back */
- X regtail(next, regnode(BRANCH)); /* or */
- X regtail(ret, regnode(NOTHING)); /* null. */
- X } else if (op == '?') {
- X /* Emit x? as (x|) */
- X reginsert(BRANCH, ret); /* Either x */
- X regtail(ret, regnode(BRANCH)); /* or */
- X next = regnode(NOTHING); /* null. */
- X regtail(ret, next);
- X regoptail(ret, next);
- X }
- X regparse++;
- X if (ISMULT(*regparse))
- X FAIL("nested *?+");
- X
- X return(ret);
- X}
- X
- X/*
- X - regatom - the lowest level
- X *
- X * Optimization: gobbles an entire sequence of ordinary characters so that
- X * it can turn them into a single node, which is smaller to store and
- X * faster to run. Backslashed characters are exceptions, each becoming a
- X * separate node; the code is simpler that way and it's not worth fixing.
- X */
- Xstatic char *
- Xregatom(flagp)
- Xint *flagp;
- X{
- X register char *ret;
- X int flags;
- X
- X *flagp = WORST; /* Tentatively. */
- X
- X switch (*regparse++) {
- X case '^':
- X ret = regnode(BOL);
- X break;
- X case '$':
- X ret = regnode(EOL);
- X break;
- X case '.':
- X ret = regnode(ANY);
- X *flagp |= HASWIDTH|SIMPLE;
- X break;
- X case '[': {
- X register int class;
- X register int classend;
- X
- X if (*regparse == '^') { /* Complement of range. */
- X ret = regnode(ANYBUT);
- X regparse++;
- X } else
- X ret = regnode(ANYOF);
- X if (*regparse == ']' || *regparse == '-')
- X regc(*regparse++);
- X while (*regparse != '\0' && *regparse != ']') {
- X if (*regparse == '-') {
- X regparse++;
- X if (*regparse == ']' || *regparse == '\0')
- X regc('-');
- X else {
- X class = UCHARAT(regparse-2)+1;
- X classend = UCHARAT(regparse);
- X if (class > classend+1)
- X FAIL("invalid [] range");
- X for (; class <= classend; class++)
- X regc(class);
- X regparse++;
- X }
- X } else
- X regc(*regparse++);
- X }
- X regc('\0');
- X if (*regparse != ']')
- X FAIL("unmatched []");
- X regparse++;
- X *flagp |= HASWIDTH|SIMPLE;
- X }
- X break;
- X case '(':
- X ret = reg(1, &flags);
- X if (ret == NULL)
- X return(NULL);
- X *flagp |= flags&(HASWIDTH|SPSTART);
- X break;
- X case '\0':
- X case '|':
- X case ')':
- X FAIL("internal urp"); /* Supposed to be caught earlier. */
- X break;
- X case '?':
- X case '+':
- X case '*':
- X FAIL("?+* follows nothing");
- X break;
- X case '\\':
- X if (*regparse == '\0')
- X FAIL("trailing \\");
- X ret = regnode(EXACTLY);
- X regc(*regparse++);
- X regc('\0');
- X *flagp |= HASWIDTH|SIMPLE;
- X break;
- X default: {
- X register int len;
- X register char ender;
- X
- X regparse--;
- X len = strcspn(regparse, META);
- X if (len <= 0)
- X FAIL("internal disaster");
- X ender = *(regparse+len);
- X if (len > 1 && ISMULT(ender))
- X len--; /* Back off clear of ?+* operand. */
- X *flagp |= HASWIDTH;
- X if (len == 1)
- X *flagp |= SIMPLE;
- X ret = regnode(EXACTLY);
- X while (len > 0) {
- X regc(*regparse++);
- X len--;
- X }
- X regc('\0');
- X }
- X break;
- X }
- X
- X return(ret);
- X}
- X
- X/*
- X - regnode - emit a node
- X */
- Xstatic char * /* Location. */
- Xregnode(op)
- Xchar op;
- X{
- X register char *ret;
- X register char *ptr;
- X
- X ret = regcode;
- X if (ret == ®dummy) {
- X regsize += 3;
- X return(ret);
- X }
- X
- X ptr = ret;
- X *ptr++ = op;
- X *ptr++ = '\0'; /* Null "next" pointer. */
- X *ptr++ = '\0';
- X regcode = ptr;
- X
- X return(ret);
- X}
- X
- X/*
- X - regc - emit (if appropriate) a byte of code
- X */
- Xstatic void
- Xregc(b)
- Xchar b;
- X{
- X if (regcode != ®dummy)
- X *regcode++ = b;
- X else
- X regsize++;
- X}
- X
- X/*
- X - reginsert - insert an operator in front of already-emitted operand
- X *
- X * Means relocating the operand.
- X */
- Xstatic void
- Xreginsert(op, opnd)
- Xchar op;
- Xchar *opnd;
- X{
- X register char *src;
- X register char *dst;
- X register char *place;
- X
- X if (regcode == ®dummy) {
- X regsize += 3;
- X return;
- X }
- X
- X src = regcode;
- X regcode += 3;
- X dst = regcode;
- X while (src > opnd)
- X *--dst = *--src;
- X
- X place = opnd; /* Op node, where operand used to be. */
- X *place++ = op;
- X *place++ = '\0';
- X *place++ = '\0';
- X}
- X
- X/*
- X - regtail - set the next-pointer at the end of a node chain
- X */
- Xstatic void
- Xregtail(p, val)
- Xchar *p;
- Xchar *val;
- X{
- X register char *scan;
- X register char *temp;
- X register int offset;
- X
- X if (p == ®dummy)
- X return;
- X
- X /* Find last node. */
- X scan = p;
- X for (;;) {
- X temp = regnext(scan);
- X if (temp == NULL)
- X break;
- X scan = temp;
- X }
- X
- X if (OP(scan) == BACK)
- X offset = scan - val;
- X else
- X offset = val - scan;
- X *(scan+1) = (offset>>8)&0377;
- X *(scan+2) = offset&0377;
- X}
- X
- X/*
- X - regoptail - regtail on operand of first argument; nop if operandless
- X */
- Xstatic void
- Xregoptail(p, val)
- Xchar *p;
- Xchar *val;
- X{
- X /* "Operandless" and "op != BRANCH" are synonymous in practice. */
- X if (p == NULL || p == ®dummy || OP(p) != BRANCH)
- X return;
- X regtail(OPERAND(p), val);
- X}
- X
- X/*
- X * regexec and friends
- X */
- X
- X/*
- X * Global work variables for regexec().
- X */
- Xstatic char *reginput; /* String-input pointer. */
- Xstatic char *regbol; /* Beginning of input, for ^ check. */
- Xstatic char **regstartp; /* Pointer to startp array. */
- Xstatic char **regendp; /* Ditto for endp. */
- X
- X/*
- X * Forwards.
- X */
- XSTATIC int regtry();
- XSTATIC int regmatch();
- XSTATIC int regrepeat();
- X
- X#ifdef DEBUG
- Xint regnarrate = 0;
- Xvoid regdump();
- XSTATIC char *regprop();
- X#endif
- X
- X/*
- X - regexec - match a regexp against a string
- X */
- Xint
- Xregexec(prog, string)
- Xregister regexp *prog;
- Xregister char *string;
- X{
- X register char *s;
- X extern char *strchr();
- X
- X /* Be paranoid... */
- X if (prog == NULL || string == NULL) {
- X regerror("NULL parameter");
- X return(0);
- X }
- X
- X /* Check validity of program. */
- X if (UCHARAT(prog->program) != MAGIC) {
- X regerror("corrupted program");
- X return(0);
- X }
- X
- X /* If there is a "must appear" string, look for it. */
- X if (prog->regmust != NULL) {
- X s = string;
- X while ((s = strchr(s, prog->regmust[0])) != NULL) {
- X if (strncmp(s, prog->regmust, prog->regmlen) == 0)
- X break; /* Found it. */
- X s++;
- X }
- X if (s == NULL) /* Not present. */
- X return(0);
- X }
- X
- X /* Mark beginning of line for ^ . */
- X regbol = string;
- X
- X /* Simplest case: anchored match need be tried only once. */
- X if (prog->reganch)
- X return(regtry(prog, string));
- X
- X /* Messy cases: unanchored match. */
- X s = string;
- X if (prog->regstart != '\0')
- X /* We know what char it must start with. */
- X while ((s = strchr(s, prog->regstart)) != NULL) {
- X if (regtry(prog, s))
- X return(1);
- X s++;
- X }
- X else
- X /* We don't -- general case. */
- X do {
- X if (regtry(prog, s))
- X return(1);
- X } while (*s++ != '\0');
- X
- X /* Failure. */
- X return(0);
- X}
- X
- X/*
- X - regtry - try match at specific point
- X */
- Xstatic int /* 0 failure, 1 success */
- Xregtry(prog, string)
- Xregexp *prog;
- Xchar *string;
- X{
- X register int i;
- X register char **sp;
- X register char **ep;
- X
- X reginput = string;
- X regstartp = prog->startp;
- X regendp = prog->endp;
- X
- X sp = prog->startp;
- X ep = prog->endp;
- X for (i = NSUBEXP; i > 0; i--) {
- X *sp++ = NULL;
- X *ep++ = NULL;
- X }
- X if (regmatch(prog->program + 1)) {
- X prog->startp[0] = string;
- X prog->endp[0] = reginput;
- X return(1);
- X } else
- X return(0);
- X}
- X
- X/*
- X - regmatch - main matching routine
- X *
- X * Conceptually the strategy is simple: check to see whether the current
- X * node matches, call self recursively to see whether the rest matches,
- X * and then act accordingly. In practice we make some effort to avoid
- X * recursion, in particular by going through "ordinary" nodes (that don't
- X * need to know whether the rest of the match failed) by a loop instead of
- X * by recursion.
- X */
- Xstatic int /* 0 failure, 1 success */
- Xregmatch(prog)
- Xchar *prog;
- X{
- X register char *scan; /* Current node. */
- X char *next; /* Next node. */
- X extern char *strchr();
- X
- X scan = prog;
- X#ifdef DEBUG
- X if (scan != NULL && regnarrate)
- X fprintf(stderr, "%s(\n", regprop(scan));
- X#endif
- X while (scan != NULL) {
- X#ifdef DEBUG
- X if (regnarrate)
- X fprintf(stderr, "%s...\n", regprop(scan));
- X#endif
- X next = regnext(scan);
- X
- X switch (OP(scan)) {
- X case BOL:
- X if (reginput != regbol)
- X return(0);
- X break;
- X case EOL:
- X if (*reginput != '\0')
- X return(0);
- X break;
- X case ANY:
- X if (*reginput == '\0')
- X return(0);
- X reginput++;
- X break;
- X case EXACTLY: {
- X register int len;
- X register char *opnd;
- X
- X opnd = OPERAND(scan);
- X /* Inline the first character, for speed. */
- X if (*opnd != *reginput)
- X return(0);
- X len = strlen(opnd);
- X if (len > 1 && strncmp(opnd, reginput, len) != 0)
- X return(0);
- X reginput += len;
- X }
- X break;
- X case ANYOF:
- X if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL)
- X return(0);
- X reginput++;
- X break;
- X case ANYBUT:
- X if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL)
- X return(0);
- X reginput++;
- X break;
- X case NOTHING:
- X break;
- X case BACK:
- X break;
- X case OPEN+1:
- X case OPEN+2:
- X case OPEN+3:
- X case OPEN+4:
- X case OPEN+5:
- X case OPEN+6:
- X case OPEN+7:
- X case OPEN+8:
- X case OPEN+9: {
- X register int no;
- X register char *save;
- X
- X no = OP(scan) - OPEN;
- X save = reginput;
- X
- X if (regmatch(next)) {
- X /*
- X * Don't set startp if some later
- X * invocation of the same parentheses
- X * already has.
- X */
- X if (regstartp[no] == NULL)
- X regstartp[no] = save;
- X return(1);
- X } else
- X return(0);
- X }
- X break;
- X case CLOSE+1:
- X case CLOSE+2:
- X case CLOSE+3:
- X case CLOSE+4:
- X case CLOSE+5:
- X case CLOSE+6:
- X case CLOSE+7:
- X case CLOSE+8:
- X case CLOSE+9: {
- X register int no;
- X register char *save;
- X
- X no = OP(scan) - CLOSE;
- X save = reginput;
- X
- X if (regmatch(next)) {
- X /*
- X * Don't set endp if some later
- X * invocation of the same parentheses
- X * already has.
- X */
- X if (regendp[no] == NULL)
- X regendp[no] = save;
- X return(1);
- X } else
- X return(0);
- X }
- X break;
- X case BRANCH: {
- X register char *save;
- X
- X if (OP(next) != BRANCH) /* No choice. */
- X next = OPERAND(scan); /* Avoid recursion. */
- X else {
- X do {
- X save = reginput;
- X if (regmatch(OPERAND(scan)))
- X return(1);
- X reginput = save;
- X scan = regnext(scan);
- X } while (scan != NULL && OP(scan) == BRANCH);
- X return(0);
- X /* NOTREACHED */
- X }
- X }
- X break;
- X case STAR:
- X case PLUS: {
- X register char nextch;
- X register int no;
- X register char *save;
- X register int min;
- X
- X /*
- X * Lookahead to avoid useless match attempts
- X * when we know what character comes next.
- X */
- X nextch = '\0';
- X if (OP(next) == EXACTLY)
- X nextch = *OPERAND(next);
- X min = (OP(scan) == STAR) ? 0 : 1;
- X save = reginput;
- X no = regrepeat(OPERAND(scan));
- X while (no >= min) {
- X /* If it could work, try it. */
- X if (nextch == '\0' || *reginput == nextch)
- X if (regmatch(next))
- X return(1);
- X /* Couldn't or didn't -- back up. */
- X no--;
- X reginput = save + no;
- X }
- X return(0);
- X }
- X break;
- X case END:
- X return(1); /* Success! */
- X break;
- X default:
- X regerror("memory corruption");
- X return(0);
- X break;
- X }
- X
- X scan = next;
- X }
- X
- X /*
- X * We get here only if there's trouble -- normally "case END" is
- X * the terminating point.
- X */
- X regerror("corrupted pointers");
- X return(0);
- X}
- X
- X/*
- X - regrepeat - repeatedly match something simple, report how many
- X */
- Xstatic int
- Xregrepeat(p)
- Xchar *p;
- X{
- X register int count = 0;
- X register char *scan;
- X register char *opnd;
- X
- X scan = reginput;
- X opnd = OPERAND(p);
- X switch (OP(p)) {
- X case ANY:
- X count = strlen(scan);
- X scan += count;
- X break;
- X case EXACTLY:
- X while (*opnd == *scan) {
- X count++;
- X scan++;
- X }
- X break;
- X case ANYOF:
- X while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
- X count++;
- X scan++;
- X }
- X break;
- X case ANYBUT:
- X while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
- X count++;
- X scan++;
- X }
- X break;
- X default: /* Oh dear. Called inappropriately. */
- X regerror("internal foulup");
- X count = 0; /* Best compromise. */
- X break;
- X }
- X reginput = scan;
- X
- X return(count);
- X}
- X
- X/*
- X - regnext - dig the "next" pointer out of a node
- X */
- Xstatic char *
- Xregnext(p)
- Xregister char *p;
- X{
- X register int offset;
- X
- X if (p == ®dummy)
- X return(NULL);
- X
- X offset = NEXT(p);
- X if (offset == 0)
- X return(NULL);
- X
- X if (OP(p) == BACK)
- X return(p-offset);
- X else
- X return(p+offset);
- X}
- X
- X#ifdef DEBUG
- X
- XSTATIC char *regprop();
- X
- X/*
- X - regdump - dump a regexp onto stdout in vaguely comprehensible form
- X */
- Xvoid
- Xregdump(r)
- Xregexp *r;
- X{
- X register char *s;
- X register char op = EXACTLY; /* Arbitrary non-END op. */
- X register char *next;
- X extern char *strchr();
- X
- X
- X s = r->program + 1;
- X while (op != END) { /* While that wasn't END last time... */
- X op = OP(s);
- X printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */
- X next = regnext(s);
- X if (next == NULL) /* Next ptr. */
- X printf("(0)");
- X else
- X printf("(%d)", (s-r->program)+(next-s));
- X s += 3;
- X if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
- X /* Literal string, where present. */
- X while (*s != '\0') {
- X putchar(*s);
- X s++;
- X }
- X s++;
- X }
- X putchar('\n');
- X }
- X
- X /* Header fields of interest. */
- X if (r->regstart != '\0')
- X printf("start `%c' ", r->regstart);
- X if (r->reganch)
- X printf("anchored ");
- X if (r->regmust != NULL)
- X printf("must have \"%s\"", r->regmust);
- X printf("\n");
- X}
- X
- X/*
- X - regprop - printable representation of opcode
- X */
- Xstatic char *
- Xregprop(op)
- Xchar *op;
- X{
- X register char *p;
- X static char buf[50];
- X
- X (void) strcpy(buf, ":");
- X
- X switch (OP(op)) {
- X case BOL:
- X p = "BOL";
- X break;
- X case EOL:
- X p = "EOL";
- X break;
- X case ANY:
- X p = "ANY";
- X break;
- X case ANYOF:
- X p = "ANYOF";
- X break;
- X case ANYBUT:
- X p = "ANYBUT";
- X break;
- X case BRANCH:
- X p = "BRANCH";
- X break;
- X case EXACTLY:
- X p = "EXACTLY";
- X break;
- X case NOTHING:
- X p = "NOTHING";
- X break;
- X case BACK:
- X p = "BACK";
- X break;
- X case END:
- X p = "END";
- X break;
- X case OPEN+1:
- X case OPEN+2:
- X case OPEN+3:
- X case OPEN+4:
- X case OPEN+5:
- X case OPEN+6:
- X case OPEN+7:
- X case OPEN+8:
- X case OPEN+9:
- X sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
- X p = NULL;
- X break;
- X case CLOSE+1:
- X case CLOSE+2:
- X case CLOSE+3:
- X case CLOSE+4:
- X case CLOSE+5:
- X case CLOSE+6:
- X case CLOSE+7:
- X case CLOSE+8:
- X case CLOSE+9:
- X sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
- X p = NULL;
- X break;
- X case STAR:
- X p = "STAR";
- X break;
- X case PLUS:
- X p = "PLUS";
- X break;
- X default:
- X regerror("corrupted opcode");
- X break;
- X }
- X if (p != NULL)
- X (void) strcat(buf, p);
- X return(buf);
- X}
- X#endif
- X
- X/*
- X * The following is provided for those people who do not have strcspn() in
- X * their C libraries. They should get off their butts and do something
- X * about it; at least one public-domain implementation of those (highly
- X * useful) string routines has been published on Usenet.
- X */
- X#ifdef STRCSPN
- X/*
- X * strcspn - find length of initial segment of s1 consisting entirely
- X * of characters not from s2
- X */
- X
- Xstatic int
- Xstrcspn(s1, s2)
- Xchar *s1;
- Xchar *s2;
- X{
- X register char *scan1;
- X register char *scan2;
- X register int count;
- X
- X count = 0;
- X for (scan1 = s1; *scan1 != '\0'; scan1++) {
- X for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */
- X if (*scan1 == *scan2++)
- X return(count);
- X count++;
- X }
- X return(count);
- X}
- X#endif
- END_OF_regexp.c
- if test 27732 -ne `wc -c <regexp.c`; then
- echo shar: \"regexp.c\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f wns.c -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"wns.c\"
- else
- echo shar: Extracting \"wns.c\" \(12950 characters\)
- sed "s/^X//" >wns.c <<'END_OF_wns.c'
- X/* wns.c - Search for string and print window of lines around it.
- X
- X Nov 19 1984 Mark Mallett (mem@zinn.MV.COM)
- X
- Xmem 860224 Modified to do r/e (regular expression) parsing on unix
- Xmem 860324 Added -f, -n; added code to number lines correctly on
- X output.
- Xmem 870325 Added support for regcmp()/regex() style regular expression
- X library; redid some conditionals to provide better mix'n'match.
- Xmem 870326 Don't try to print the filename if reading from stdin.
- X Add -w option. Fix a small problem which occasionally allowed
- X the separator to come out between adjacent lines of the file.
- Xmem 871119 Fix semantics of call to regcmp(): the NULL terminating the
- X argument list was missing. It worked, but probably only
- X due to some bizarre coincidence.
- X
- X Changes by Mark Rinfret for Amiga (mrr@amanpt1.ZONE1.COM)
- X
- Xmrr 881009 Use V8 regexp routines (since I had 'em)
- X
- X*/
- X
- X/* The appropriate defines are done in the makefile */
- X/* #define OS_UNIX */ /* Define this for unix systems */
- X/* #define SYSINC */ /* Define this for sys/ include hierarchy */
- X/* #define REGEX */ /* Define this for re_comp/re_exec library */
- X/* #define REGCMP */ /* Define this to use regcmp/regex */
- X/* #define REGCOMP */ /* Define this to use regcomp/regexec */
- X/* #define OS_CPM */ /* Define this for CP/M-80 */
- X
- X
- X/* Don't touch these */
- X#define NOREGEXP /* Set this for no regular expression */
- X#ifdef REGEX
- X#undef NOREGEXP
- X#endif REGEX
- X
- X#ifdef REGCMP
- X#undef NOREGEXP
- X#endif REGCMP
- X
- X#ifdef REGCOMP
- X#undef NOREGEXP
- X#endif
- X
- X
- X#ifdef OS_CPM
- X#include "stdio.h"
- X#include "ctype.h"
- X#endif OS_CPM
- X
- X#ifdef OS_UNIX
- X#include <stdio.h>
- X#include <ctype.h>
- X
- X#ifdef SYSINC
- X#include <sys/types.h>
- X#include <sys/dir.h>
- X#else /* !SYSINC */
- X#ifndef AMIGA
- X#include <types.h>
- X#include <dir.h>
- X#endif
- X#endif SYSINC
- X#endif OS_UNIX
- X
- Xchar *calloc();
- Xchar *fgets();
- X
- X/* Local definitions */
- X
- X#ifndef NULL
- X#define NULL ((char *)0)
- X#endif NULL
- X
- X#ifndef NUL
- X#define NUL '\000'
- X#endif
- X
- X#ifndef TRUE
- X#define TRUE 1
- X#define FALSE 0
- X#endif
- X
- X
- X/* Internal data declared global */
- X
- X
- X/* Internal routines */
- X
- X
- X/* External data */
- X
- X
- X/* External routines */
- X
- X#ifdef REGEX /* re_comp/ re_exec */
- Xextern char *re_comp(); /* r/e compile */
- Xextern int re_exec(); /* r/e exec */
- X#endif REGEX
- X
- X#ifdef REGCMP /* regcmp/regex */
- Xextern char *regcmp(); /* r/e compile */
- Xextern char *regex(); /* r/e exec */
- X#endif REGCMP
- X
- X#ifdef REGCOMP /* regcomp/regexec */
- Xextern char *regcomp();
- Xextern char *regexec();
- X#endif
- X
- X
- X/* Local data */
- X
- Xstatic int Debug={FALSE}; /* Debug enabled flag */
- Xstatic int Lcur = {0}; /* Current line (in Lines array) */
- Xstatic char **Lines = {(char **)NULL}; /* Lines pointer array */
- Xstatic int Linlen = {100}; /* Line length */
- Xstatic int Lone = {0}; /* Line one (in Lines array) */
- Xstatic int Nmr = {0}; /* Number of matched regions */
- Xstatic char *Pat = {NULL}; /* Pattern */
- Xstatic char Shwfile = {TRUE}; /* Show file name... */
- Xstatic char Shwline = {TRUE}; /* Show line number */
- Xstatic int Waft = {0}; /* Window after */
- Xstatic int Wbef = {0}; /* Window before */
- Xstatic int Wsiz = {0}; /* Window size */
- X
- X#ifdef REGEX /* regex style r/e manipulations */
- Xchar *Re; /* Result from re_comp() */
- X#endif REGEX
- X
- X#ifdef REGCMP /* regcmp style r/e */
- Xchar *Re; /* Result from regcmp() */
- X#endif REGCMP
- X
- X#ifdef REGCOMP
- Xchar *Re; /* Result from regcomp() */
- X#endif REGCOMP
- X
- Xmain (argc, argv)
- X
- Xint argc; /* Argument count */
- Xchar **argv; /* Argument values */
- X
- X{
- Xint i; /* Scratch */
- Xint n; /* Scratch again */
- Xint c; /* A character */
- Xchar *aptr; /* Argument pointer */
- Xint nf; /* number of files on command line */
- X
- Xnf = 0; /* No files on line */
- X
- Xfor (i = 1; i < argc; i++) /* Look at args */
- X {
- X if (argv[i][0] != '-') /* If option */
- X {
- X if (Pat == NULL) /* If no pattern yet given */
- X {
- X Pat = argv[i]; /* point here */
- X#ifdef REGEX
- X if ((Re = re_comp(Pat)) != NULL)
- X {
- X fprintf(stderr, "wns: %s\n", re);
- X exit(1);
- X }
- X#endif REGEX
- X
- X#ifdef REGCMP
- X if ((Re = regcmp(Pat, NULL)) == NULL)
- X {
- X fprintf(stderr, "wns: error in regular expression.\n");
- X exit(1);
- X }
- X#endif REGCMP
- X
- X#ifdef REGCOMP
- X if ((Re = regcomp(Pat, NULL)) == NULL)
- X {
- X fprintf(stderr, "wns: error in regular expression.\n");
- X exit(1);
- X }
- X#endif REGCOMP
- X
- X }
- X else /* This must be a file to search */
- X {
- X#ifdef AMIGA
- X /* On the Amiga, we may have to do wildcard expansion. */
- X#ifdef AZTEC_C
- X /* Aztec provides a method for this. I don't know what
- X * Lattice provides. Sorry.
- X */
- X char *scdir(); /* Aztec C wildcard expansion */
- X char *fName; /* filename back from scdir() */
- X int isWild;
- X char testChar;
- X
- X /* Because the Aztec scdir() routine is so slow (due to
- X * directory scanning), avoid its use if possible. Only call
- X * scdir() if we have a filename with wildcard characters.
- X */
- X isWild = 0;
- X for (fName = argv[i]; testChar = *fName++; )
- X if (testChar == '*' || testChar == '?') {
- X ++isWild; /* Filename has wildcards. */
- X break;
- X }
- X
- X if (isWild) {
- X while (fName = scdir(argv[i])) {
- X nf++;
- X dosrch(fName);
- X }
- X }
- X else {
- X nf++;
- X dosrch(argv[i]);
- X }
- X#else
- X /* Lattice variant of wildcard handling goes here. */
- X nf++;
- X dosrch(argv[i]);
- X#endif
- X#else
- X nf++; /* Count it */
- X dosrch (argv[i]); /* Search */
- X#endif
- X }
- X }
- X
- X else /* Option char */
- X {
- X c = argv[i][1]; /* Get option char */
- X if (isupper(c)) /* Trap idiot definition of tolower */
- X c = tolower(c); /* Don't care about case */
- X n = i;
- X aptr = NULL; /* Find arg, if any */
- X if (argv[i][2] != NUL)
- X {
- X aptr = &argv[i][2];
- X n = i; /* Where to set i if we use this arg */
- X }
- X else if (i < argc-1) /* use next.. */
- X {
- X n = i+1;
- X aptr = argv[n];
- X }
- X
- X switch (c) /* Process the option */
- X {
- X case 'a': /* Lines after */
- X Waft = atoi (aptr);
- X Lines = NULL;
- X i = n;
- X break;
- X
- X case 'b': /* Lines before */
- X Wbef = atoi (aptr);
- X Lines = (char **)NULL;
- X i = n;
- X break;
- X
- X case 'd': /* Enable debugging */
- X Debug = TRUE;
- X break;
- X
- X case 'f': /* Suppress filename on output */
- X Shwfile = FALSE;
- X break;
- X
- X case 'l': /* Line length */
- X Linlen = atoi (aptr);
- X Lines = NULL;
- X i = n;
- X break;
- X
- X case 'n': /* Suppress line number on output */
- X Shwline = FALSE;
- X break;
- X
- X case 'w': /* Window: lines before and after */
- X Waft = Wbef = atoi (aptr);
- X Lines = NULL;
- X i = n;
- X break;
- X
- X default:
- X fprintf (stderr, "Invalid option %s\n",argv[i]);
- X exit(1);
- X }
- X }
- X }
- X
- Xif ( Pat == NULL ) /* If no pattern given */
- X {
- X fprintf(stderr,
- X"usage: wns [-a n] [-b n] [-d] [-f] [-l n] [-n] [-w n] pattern [filename... ]\n");
- X exit(1);
- X }
- X
- Xif (nf == 0) /* No files processed ? */
- X dosrch (NULL); /* Do standard input */
- X
- X exit(0);
- X}
- X/*
- X
- X*//* dosrch (ifnm)
- X
- X Perform the search
- X
- XAccepts :
- X
- X ifn Input file name
- X
- X
- XReturns :
- X
- X
- X*/
- X
- Xdosrch (ifnm)
- X
- Xchar *ifnm; /* Input filelname */
- X
- X{
- XFILE *ifp; /* Input fp */
- Xchar *lptr; /* Line pointer */
- Xint i; /* Scratch */
- Xint prtaft; /* Print-after count */
- Xint linnum; /* Line number */
- Xint nlb; /* Number of lines buffered */
- X
- Xif (ifnm != NULL) /* If file name given */
- X {
- X ifp = fopen (ifnm, "r"); /* Open it for read access */
- X if (ifp == NULL)
- X {
- X fprintf (stderr, "Can not open file %s\n", ifnm);
- X return;
- X }
- X }
- Xelse
- X ifp = stdin;
- X
- Xif (Lines == NULL) /* If no line table allocated.. */
- X {
- X Wsiz = Wbef+2; /* Determine total window size */
- X Lines = (char **) calloc (Wsiz, sizeof (char *));
- X /* Allocate pointer table */
- X for (i = 0; i < Wsiz; i++) /* Allocate line buffers */
- X Lines[i] = (char *) calloc (Linlen, sizeof(char));
- X }
- X
- XLcur = Lone = 0; /* Setup line pointers */
- Xnlb = 0; /* No lines buffered */
- Xlinnum = 0; /* Line number is zero */
- Xprtaft = -(Wbef+1); /* Make sure separator given first time */
- X
- Xfor (;;) /* Loop through the file */
- X {
- X lptr = Lines[Lcur]; /* Get pointer to current line */
- X if (++Lcur == Wsiz) /* Bump curr pointer and wrap */
- X Lcur = 0; /* if hit end */
- X if (Lone == Lcur) /* If wrapped to beginning of window */
- X if (++Lone == Wsiz) /* Bump beginning */
- X Lone = 0; /* and wrap if hit end */
- X
- X if (fgets (lptr, Linlen, ifp) != lptr)
- X break; /* if end of file */
- X
- X linnum++; /* Count line number */
- X if (matlin (lptr)) /* If matching line */
- X {
- X if (prtaft < (-Wbef) ) /* Check for separator needed */
- X if ( (Nmr++ > 0 ) && ((Wbef > 0) || (Waft > 0)) )
- X printf ("-------------------\n");
- X while (Lone != Lcur) /* Until we close the window */
- X {
- X shwlin (ifnm, linnum-nlb, Lines[Lone]);
- X /* Show the line */
- X if (++Lone == Wsiz)
- X Lone = 0;
- X nlb--;
- X }
- X nlb = 0; /* No lines buffered */
- X prtaft = Waft; /* Print n lines after */
- X }
- X
- X else /* Didn't match */
- X {
- X if (prtaft-- > 0) /* If must print lines after */
- X {
- X shwlin (ifnm, linnum, lptr);
- X /* Show the line */
- X Lone = Lcur; /* Match pointers */
- X }
- X else if (nlb < Wbef) /* Count lines buffered */
- X nlb++;
- X }
- X }
- X
- Xif (ifnm != NULL)
- X fclose (ifp);
- X}
- X/*
- X
- X*//* shwlin (fnm, linnum, line)
- X
- X Show a matching line
- X
- X
- XAccepts :
- X
- X fnm File name
- X
- X linnum Line number
- X
- X line Line to show
- X
- X
- XReturns :
- X
- X
- X*/
- X
- Xshwlin (fnm, linnum, line)
- X
- Xchar *fnm; /* File name */
- Xint linnum; /* Line number */
- Xchar *line; /* Line (with newline at end) to print */
- X
- X{
- Xif (Shwfile && ( fnm != NULL) )
- X printf("%s%s", fnm, Shwline?" ":":");
- Xif (Shwline)
- X printf("@%05d%:", linnum);
- Xprintf ("%s", line);
- X}
- X/*
- X
- X*//* matlin (line)
- X
- X Perform match against pattern and line
- X
- X
- XAccepts :
- X
- X line Address of line to match
- X
- X
- XReturns :
- X
- X <value> TRUE if match
- X FALSE if not
- X
- X
- X*/
- X
- X
- Xint matlin (line)
- X
- Xchar *line; /* Line to match */
- X
- X{
- Xint rtncode; /* Return value from this routine */
- X
- X
- X#ifdef NOREGEXP
- Xchar *pptr, *lptr, *tlptr;
- Xint c1,c2;
- X#endif NOREGEXP
- X
- Xif (Debug)
- X printf ("Matching %s against %s", Pat, line);
- X
- X#ifdef REGEX
- Xrtncode = re_exec(line); /* Hand off to r/e evaluator */
- X#endif REGEX
- X
- X#ifdef REGCMP
- Xrtncode = ( regex( Re, line ) != NULL );
- X#endif REGCMP
- X
- X#ifdef REGCOMP
- Xrtncode = ( regexec( Re, line ) != NULL );
- X#endif REGCOMP
- X
- X#ifdef NOREGEX /* Have to do menial comparison.. */
- Xlptr = line; /* Init line pointer */
- X
- Xfor ( rtncode = -1; rtncode < 0; )
- X {
- X tlptr = lptr++; /* Get temp ptr to line */
- X pptr = Pat; /* Get ptr to pattern */
- X while (TRUE)
- X {
- X if ((c1 = *pptr++) == NUL)
- X {
- X rtncode = 1; /* GOOD return value */
- X break;
- X }
- X if ((c2 = *tlptr++) == NUL)
- X {
- X rtncode = 0; /* BAD return value */
- X break;
- X }
- X if (isupper(c1))
- X c1 = tolower(c1);
- X if (isupper(c2))
- X c2 = tolower(c2);
- X if (c1 != c2)
- X break;
- X }
- X }
- X#endif NOREGEX
- X
- X
- Xif (Debug)
- X printf("matlin returned %s\n", rtncode?"TRUE":"FALSE");
- Xreturn(rtncode);
- X}
- X
- X
- END_OF_wns.c
- if test 12950 -ne `wc -c <wns.c`; then
- echo shar: \"wns.c\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f wns.man -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"wns.man\"
- else
- echo shar: Extracting \"wns.man\" \(2415 characters\)
- sed "s/^X//" >wns.man <<'END_OF_wns.man'
- X
- X
- X
- X WNS(1) WNS(1)
- X
- X
- X
- X NAME
- X wns - windowing search
- X
- X SYNOPSIS
- X wns [-a nnn] [-b nnn] [-l nnn] [-w nnn] pattern [file ... ]
- X
- X DESCRIPTION
- X _w_n_s searches through a file or list of files for occurances
- X of a particular pattern, and prints a window of lines around
- X each match point.
- X
- X Options which may be given are as follows:
- X
- X -a nnn
- X (After) specifies that nnn lines following the matching
- X line will be printed. default is 0.
- X
- X -b nnn
- X (Before) specifies that nnn lines preceding the
- X matching line will be printed. default is 0.
- X
- X -d Enables debugging information. Not a very interesting
- X option.
- X
- X -f Suppress printing of the filename on each output line.
- X
- X -l nnn
- X Sets the maximum line length to nnn. Lines longer than
- X this will be truncated to this length before attempting
- X to match them to the pattern as well as when printing
- X them. Default is 100.
- X
- X -n Suppress printing of the line number on each output
- X line.
- X
- X -w nnn
- X Sets the window size to nnn. This is the same as -a
- X nnn -b nnn.
- X
- X _w_n_s outputs lines in the following format:
- X
- X filename @nnnnn: text
- X
- X where _f_i_l_e_n_a_m_e is the name of the file containing the
- X matching text and may be suppressed with the -f option,
- X _l_n_n_n_n is the line number of the displayed line and may be
- X suppressed with the -n option, and _t_e_x_t is the line from the
- X file. Additionally, if the total window size is greater
- X than 1 (that is, more than zero lines before or after), then
- X non-adjacent text areas are separated by a short dashed
- X line.
- X
- X
- X
- X
- X Page 1 (printed 9/23/88)
- X
- X
- X
- X
- X
- X
- X WNS(1) WNS(1)
- X
- X
- X
- X FILES
- X /usr/local/bin/wns /usr/local/src/wns/*
- X
- X CREDITS TO
- X M. Mallett (mem@zinn.MV.COM)
- X
- X BUGS
- X You tell me..
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X
- X Page 2 (printed 9/23/88)
- X
- X
- X
- END_OF_wns.man
- echo shar: 23 control characters may be missing from \"wns.man\"
- if test 2415 -ne `wc -c <wns.man`; then
- echo shar: \"wns.man\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- if test -f wns.1 -a "${1}" != "-c" ; then
- echo shar: Will not over-write existing file \"wns.1\"
- else
- echo shar: Extracting \"wns.1\" \(1655 characters\)
- sed "s/^X//" >wns.1 <<'END_OF_wns.1'
- X.TH WNS 1
- X.SH NAME
- Xwns \- windowing search
- X.SH SYNOPSIS
- X.B wns
- X[-a nnn]
- X[-b nnn]
- X[-l nnn]
- X[-w nnn]
- Xpattern
- X[file ... ]
- X.SH DESCRIPTION
- X.I wns
- Xsearches through a file or list of files for occurances of a particular
- Xpattern, and prints a window of lines around each match point.
- X.PP
- XOptions which may be given are as follows:
- X.TP
- X.B \-a\ nnn
- X(After) specifies that nnn lines following the matching line will be
- Xprinted. default is 0.
- X.TP
- X.B \-b\ nnn
- X(Before) specifies that nnn lines preceding the matching line will be
- Xprinted. default is 0.
- X.TP
- X.B \-d
- XEnables debugging information. Not a very interesting option.
- X.TP
- X.B \-f
- XSuppress printing of the filename on each output line.
- X.TP
- X.B \-l\ nnn
- XSets the maximum line length to nnn. Lines longer than this will be
- Xtruncated to this length before attempting to match them to the pattern as
- Xwell as when printing them. Default is 100.
- X.TP
- X.B \-n
- XSuppress printing of the line number on each output line.
- X.TP
- X.B \-w\ nnn
- XSets the window size to nnn. This is the same as -a nnn -b nnn.
- X.PP
- X.I wns
- Xoutputs lines in the following format:
- X.PP
- Xfilename @nnnnn: text
- X.PP
- Xwhere
- X.I filename
- Xis the name of the file containing the matching text and may be suppressed
- Xwith the -f option,
- X.I lnnnn
- Xis the line number of the displayed line and may be suppressed with the
- X-n option, and
- X.I text
- Xis the line from the file.
- XAdditionally, if the total window size is greater than 1 (that is, more than
- Xzero lines before or after), then non-adjacent text areas are separated by
- Xa short dashed line.
- X.SH FILES
- X/usr/local/bin/wns /usr/local/src/wns/*
- X.SH "CREDITS TO"
- XM. Mallett (mem@zinn.MV.COM)
- X.SH BUGS
- XYou tell me..
- END_OF_wns.1
- if test 1655 -ne `wc -c <wns.1`; then
- echo shar: \"wns.1\" unpacked with wrong size!
- fi
- # end of overwriting check
- fi
- echo shar: End of archive 1 \(of 1\).
- cp /dev/null ark1isdone
- MISSING=""
- for I in 1 ; do
- if test ! -f ark${I}isdone ; then
- MISSING="${MISSING} ${I}"
- fi
- done
- if test "${MISSING}" = "" ; then
- echo You have unpacked all 1 archives.
- rm -f ark[1-9]isdone
- else
- echo You still need to unpack the following archives:
- echo " " ${MISSING}
- fi
- ## End of shell archive.
- exit 0
-
-
- --
- Bob Page, U of Lowell CS Dept. page@swan.ulowell.edu ulowell!page
- "I can't tell the difference between ABC News and Hill Street Blues" -Bono
-